home *** CD-ROM | disk | FTP | other *** search
/ Motor Sport Digital Archive Collection 1960s / Motor Sport Digital Archive Collection 1960s.iso / main.swf / scripts / mx / preloaders / Preloader.as < prev   
Encoding:
Text File  |  2008-05-21  |  9.6 KB  |  301 lines
  1. package mx.preloaders
  2. {
  3.    import flash.display.DisplayObject;
  4.    import flash.display.Loader;
  5.    import flash.display.LoaderInfo;
  6.    import flash.display.MovieClip;
  7.    import flash.display.Sprite;
  8.    import flash.events.ErrorEvent;
  9.    import flash.events.Event;
  10.    import flash.events.IEventDispatcher;
  11.    import flash.events.IOErrorEvent;
  12.    import flash.events.ProgressEvent;
  13.    import flash.events.SecurityErrorEvent;
  14.    import flash.events.TimerEvent;
  15.    import flash.net.URLRequest;
  16.    import flash.system.ApplicationDomain;
  17.    import flash.system.LoaderContext;
  18.    import flash.utils.Timer;
  19.    import mx.core.mx_internal;
  20.    import mx.events.FlexEvent;
  21.    import mx.events.RSLEvent;
  22.    
  23.    use namespace mx_internal;
  24.    
  25.    public class Preloader extends Sprite
  26.    {
  27.       mx_internal static const VERSION:String = "2.0.1.0";
  28.       
  29.       private var showDisplay:Boolean;
  30.       
  31.       private var timer:Timer;
  32.       
  33.       private var rslIndex:int = 0;
  34.       
  35.       private var rslDone:Boolean = false;
  36.       
  37.       private var rslLibs:Array;
  38.       
  39.       private var displayClass:IPreloaderDisplay = null;
  40.       
  41.       public function Preloader()
  42.       {
  43.          displayClass = null;
  44.          rslIndex = 0;
  45.          rslDone = false;
  46.          super();
  47.       }
  48.       
  49.       mx_internal function rslCompleteHandler(param1:Event, param2:RSLNode) : void
  50.       {
  51.          var _loc3_:RSLEvent = null;
  52.          _loc3_ = new RSLEvent(RSLEvent.RSL_COMPLETE);
  53.          _loc3_.bytesLoaded = param2.total;
  54.          _loc3_.bytesTotal = param2.total;
  55.          _loc3_.rslIndex = param2.index;
  56.          _loc3_.rslTotal = rslLibs.length;
  57.          _loc3_.url = param2.url;
  58.          dispatchEvent(_loc3_);
  59.          loadRSL(++rslIndex);
  60.       }
  61.       
  62.       private function appProgressHandler(param1:Event) : void
  63.       {
  64.          dispatchEvent(new FlexEvent(FlexEvent.INIT_PROGRESS));
  65.       }
  66.       
  67.       mx_internal function rslErrorHandler(param1:ErrorEvent, param2:RSLNode) : void
  68.       {
  69.          var _loc3_:RSLEvent = null;
  70.          _loc3_ = new RSLEvent(RSLEvent.RSL_ERROR);
  71.          _loc3_.bytesLoaded = 0;
  72.          _loc3_.bytesTotal = 0;
  73.          _loc3_.rslIndex = param2.index;
  74.          _loc3_.rslTotal = rslLibs.length;
  75.          _loc3_.url = param2.url;
  76.          _loc3_.errorText = param1.text;
  77.          dispatchEvent(_loc3_);
  78.       }
  79.       
  80.       private function displayClassCompleteHandler(param1:Event) : void
  81.       {
  82.          dispatchEvent(new FlexEvent(FlexEvent.PRELOADER_DONE));
  83.       }
  84.       
  85.       private function timerHandler(param1:TimerEvent) : void
  86.       {
  87.          var _loc2_:Object = null;
  88.          var _loc3_:int = 0;
  89.          var _loc4_:int = 0;
  90.          if(!root)
  91.          {
  92.             return;
  93.          }
  94.          _loc2_ = getByteValues();
  95.          _loc3_ = int(_loc2_.loaded);
  96.          _loc4_ = int(_loc2_.total);
  97.          dispatchEvent(new ProgressEvent(ProgressEvent.PROGRESS,false,false,_loc3_,_loc4_));
  98.          if(rslDone && (_loc3_ >= _loc4_ && _loc4_ > 0 || _loc4_ == 0 && _loc3_ > 0 || root is MovieClip && MovieClip(root).totalFrames > 2 && MovieClip(root).framesLoaded >= 2))
  99.          {
  100.             timer.removeEventListener(TimerEvent.TIMER,timerHandler);
  101.             timer.reset();
  102.             dispatchEvent(new Event(Event.COMPLETE));
  103.             dispatchEvent(new FlexEvent(FlexEvent.INIT_PROGRESS));
  104.          }
  105.       }
  106.       
  107.       private function getByteValues() : Object
  108.       {
  109.          var _loc1_:LoaderInfo = null;
  110.          var _loc2_:int = 0;
  111.          var _loc3_:int = 0;
  112.          var _loc4_:int = 0;
  113.          var _loc5_:int = 0;
  114.          _loc1_ = root.loaderInfo;
  115.          _loc2_ = int(_loc1_.bytesLoaded);
  116.          _loc3_ = int(_loc1_.bytesTotal);
  117.          _loc4_ = !!rslLibs ? int(rslLibs.length) : 0;
  118.          _loc5_ = 0;
  119.          while(_loc5_ < _loc4_)
  120.          {
  121.             _loc2_ += rslLibs[_loc5_].loaded;
  122.             _loc3_ += rslLibs[_loc5_].total;
  123.             _loc5_++;
  124.          }
  125.          return {
  126.             "loaded":_loc2_,
  127.             "total":_loc3_
  128.          };
  129.       }
  130.       
  131.       private function ioErrorHandler(param1:IOErrorEvent) : void
  132.       {
  133.       }
  134.       
  135.       public function initialize(param1:Boolean, param2:Class, param3:uint, param4:Number, param5:Object, param6:String, param7:Number, param8:Number, param9:Array = null, param10:Array = null) : void
  136.       {
  137.          var _loc11_:int = 0;
  138.          var _loc12_:int = 0;
  139.          var _loc13_:URLRequest = null;
  140.          var _loc14_:int = 0;
  141.          var _loc15_:RSLNode = null;
  142.          root.loaderInfo.addEventListener(IOErrorEvent.IO_ERROR,ioErrorHandler);
  143.          if(Boolean(param9) && param9.length > 0)
  144.          {
  145.             rslLibs = [];
  146.             _loc11_ = int(param9.length);
  147.             _loc12_ = 0;
  148.             while(_loc12_ < _loc11_)
  149.             {
  150.                _loc13_ = new URLRequest(param9[_loc12_]);
  151.                _loc14_ = 0;
  152.                if(Boolean(param10) && param10.length == param9.length)
  153.                {
  154.                   _loc14_ = int(param10[_loc12_]);
  155.                }
  156.                _loc15_ = new RSLNode(_loc13_,_loc12_,_loc14_,this);
  157.                rslLibs.push(_loc15_);
  158.                _loc12_++;
  159.             }
  160.             loadRSL(0);
  161.          }
  162.          else
  163.          {
  164.             rslDone = true;
  165.          }
  166.          this.showDisplay = param1;
  167.          timer = new Timer(10);
  168.          timer.addEventListener(TimerEvent.TIMER,timerHandler);
  169.          timer.start();
  170.          if(param1)
  171.          {
  172.             displayClass = new param2();
  173.             displayClass.addEventListener(Event.COMPLETE,displayClassCompleteHandler);
  174.             addChild(DisplayObject(displayClass));
  175.             displayClass.backgroundColor = param3;
  176.             displayClass.backgroundAlpha = param4;
  177.             displayClass.backgroundImage = param5;
  178.             displayClass.backgroundSize = param6;
  179.             displayClass.stageWidth = param7;
  180.             displayClass.stageHeight = param8;
  181.             displayClass.initialize();
  182.             displayClass.preloader = this;
  183.          }
  184.       }
  185.       
  186.       private function appCreationCompleteHandler(param1:FlexEvent) : void
  187.       {
  188.          dispatchAppEndEvent();
  189.       }
  190.       
  191.       mx_internal function rslProgressHandler(param1:ProgressEvent, param2:RSLNode) : void
  192.       {
  193.          var _loc3_:RSLEvent = null;
  194.          _loc3_ = new RSLEvent(RSLEvent.RSL_PROGRESS);
  195.          _loc3_.bytesLoaded = param1.bytesLoaded;
  196.          _loc3_.bytesTotal = param1.bytesTotal;
  197.          _loc3_.rslIndex = param2.index;
  198.          _loc3_.rslTotal = rslLibs.length;
  199.          _loc3_.url = param2.url;
  200.          dispatchEvent(_loc3_);
  201.       }
  202.       
  203.       private function loadRSL(param1:int) : void
  204.       {
  205.          var _loc2_:RSLNode = null;
  206.          var _loc3_:Loader = null;
  207.          var _loc4_:LoaderContext = null;
  208.          if(param1 < rslLibs.length)
  209.          {
  210.             _loc2_ = rslLibs[param1];
  211.             _loc3_ = new Loader();
  212.             _loc3_.contentLoaderInfo.addEventListener(ProgressEvent.PROGRESS,_loc2_.progressHandler);
  213.             _loc3_.contentLoaderInfo.addEventListener(Event.COMPLETE,_loc2_.completeHandler);
  214.             _loc3_.contentLoaderInfo.addEventListener(IOErrorEvent.IO_ERROR,_loc2_.errorHandler);
  215.             _loc3_.contentLoaderInfo.addEventListener(SecurityErrorEvent.SECURITY_ERROR,_loc2_.errorHandler);
  216.             _loc4_ = new LoaderContext();
  217.             _loc4_.applicationDomain = ApplicationDomain.currentDomain;
  218.             _loc3_.load(_loc2_.url,_loc4_);
  219.          }
  220.          else
  221.          {
  222.             rslDone = true;
  223.          }
  224.       }
  225.       
  226.       public function registerApplication(param1:IEventDispatcher) : void
  227.       {
  228.          param1.addEventListener("validatePropertiesComplete",appProgressHandler);
  229.          param1.addEventListener("validateSizeComplete",appProgressHandler);
  230.          param1.addEventListener("validateDisplayListComplete",appProgressHandler);
  231.          param1.addEventListener(FlexEvent.CREATION_COMPLETE,appCreationCompleteHandler);
  232.       }
  233.       
  234.       private function dispatchAppEndEvent(param1:Object = null) : void
  235.       {
  236.          dispatchEvent(new FlexEvent(FlexEvent.INIT_COMPLETE));
  237.          if(!showDisplay)
  238.          {
  239.             displayClassCompleteHandler(null);
  240.          }
  241.       }
  242.    }
  243. }
  244.  
  245. import flash.events.ErrorEvent;
  246. import flash.events.Event;
  247. import flash.events.ProgressEvent;
  248. import flash.net.URLRequest;
  249. import mx.core.mx_internal;
  250.  
  251. class RSLNode
  252. {
  253.    public var completed:Boolean = false;
  254.    
  255.    public var loaded:uint = 0;
  256.    
  257.    public var total:uint = 0;
  258.    
  259.    public var index:int;
  260.    
  261.    public var errorText:String;
  262.    
  263.    public var url:URLRequest;
  264.    
  265.    public var owner:Preloader;
  266.    
  267.    public function RSLNode(param1:URLRequest, param2:int, param3:int, param4:Preloader)
  268.    {
  269.       total = 0;
  270.       loaded = 0;
  271.       completed = false;
  272.       super();
  273.       this.url = param1;
  274.       this.index = param2;
  275.       this.total = param3;
  276.       this.owner = param4;
  277.    }
  278.    
  279.    public function errorHandler(param1:ErrorEvent) : void
  280.    {
  281.       errorText = param1.text;
  282.       completed = true;
  283.       loaded = 0;
  284.       total = 0;
  285.       owner.mx_internal::rslErrorHandler(param1,this);
  286.    }
  287.    
  288.    public function progressHandler(param1:ProgressEvent) : void
  289.    {
  290.       loaded = param1.bytesLoaded;
  291.       total = param1.bytesTotal;
  292.       owner.mx_internal::rslProgressHandler(param1,this);
  293.    }
  294.    
  295.    public function completeHandler(param1:Event) : void
  296.    {
  297.       completed = true;
  298.       owner.mx_internal::rslCompleteHandler(param1,this);
  299.    }
  300. }
  301.